#!/usr/bin/env python
#
# Copyright (C) 2008, 2009 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


__program__ = 'IVUtoPDFReport'
__version__ = 'v0.1'
__author__  = 'Domenico Maggi'


from fpdf import *
import fileinput, time, datetime, re, math



class PDF(FPDF):
        def header(this):
                # Logo
                this.image('oozz.png',20,10,30,23)
             
                # Arial bold 15
                this.set_font('Arial','B',15)
                # Move to the right
                this.cell(80)
                # Title
                this.cell(45,11,'Report Turno IVU',1,1,'C')
                # Line break
                this.ln(20)
                this.set_author("Domenico Maggi")
                this.set_creator("Domenico Maggi")
                this.set_subject('Report dati turno')
               

        # Page footer
        def footer(this):
                # Position at 1.5 cm from bottom
                this.set_y(-15)
                # Arial italic 8
                this.set_font('Arial','I',8)
                # Page number
                #this.cell(0,10,'Page '+str(this.PageNo())+'/{nb}',0,0,'C')

	def fancy_table(self,header,data):
		#Colors, line width and bold font
		self.set_fill_color(255,0,0)
		self.set_text_color(255)
		self.set_draw_color(128,0,0)
		self.set_line_width(.2)
		self.set_font('','',10)
		#Header
		w=[20,30,12,12,18,18,18,18,18,18]#,20]
		for i in range(0,len(header)):
			self.cell(w[i],7,header[i],1,0,'C',1)
		self.ln()
		#Color and font restoration
		self.set_fill_color(224,235,255)
		self.set_text_color(0)
		self.set_font('')
		#Data
		fill=0
		for row in data:
			self.cell(w[0],4,row[0],'LR',0,'L',fill)
			self.cell(w[1],4,row[1],'LR',0,'L',fill)
			self.cell(w[2],4,row[2],'LR',0,'C',fill)
			self.cell(w[3],4,row[3],'LR',0,'C',fill)
			a = secore(row[4])
			if a == '0h 0m':
			  a =''
			self.cell(w[4],4,a,'LR',0,'R',fill)
			self.cell(w[5],4,'','LR',0,'R',fill)
			b = secore(row[5])
			if b == '0h 0m':
			  b = ''
			self.cell(w[5],4,b,'LR',0,'R',fill)
			self.cell(w[7],4,'','LR',0,'R',fill)
			c = secore(row[6])
			if c == '0h 0m':
			  c = ''
			#self.cell(w[8],4,c,'LR',0,'R',fill)
			#self.cell(w[9],4,'','LR',0,'R',fill)
			self.ln()
			#fill=not fill
		self.cell(sum(w),0,'','T')
 
	def riposo_table(self,header,data):
		#Colors, line width and bold font
		sabato,domenica = '',''
		self.set_fill_color(255,0,0)
		self.set_text_color(255)
		self.set_draw_color(128,0,0)
		self.set_line_width(.2)
		self.set_font('','',10)
		#Header
		w=[20,20,18,18,18]
		for i in range(0,len(header)):
			self.cell(w[i],7,header[i],1,0,'C',1)
		self.ln()
		#Color and font restoration
		self.set_fill_color(224,235,255)
		self.set_text_color(0)
		self.set_font('')
		#Data
		fill=0
		for row in data:
			self.cell(w[0],4,row[0],'LR',0,'C',fill)
			self.cell(w[1],4,row[1],'LR',0,'C',fill)
			a =secore(row[2])
			self.cell(w[2],4,a,'LR',0,'L',fill)
			if row[3]:
			  sabato = 'sabato'
			self.cell(w[3],4,sabato,'LR',0,'C',fill)
			if row[4]:
			  self.set_text_color(255,0,0)
			  domenica = 'domenica'
			self.cell(w[4],4,domenica,'LR',0,'C',fill)
			self.set_text_color(0)
			sabato, domenica = '',''
			self.ln()
			#fill=not fill
		self.cell(sum(w),0,'','T')
		self.ln()


	def rfr_table(self,header,data):
		#Colors, line width and bold font
		self.set_fill_color(255,0,0)
		self.set_text_color(255)
		self.set_draw_color(128,0,0)
		self.set_line_width(.2)
		self.set_font('','',10)
		#Header
		w=[20,20,20]
		for i in range(0,len(header)):
			self.cell(w[i],7,header[i],1,0,'C',1)
		self.ln()
		#Color and font restoration
		self.set_fill_color(224,235,255)
		self.set_text_color(0)
		self.set_font('')
		#Data
		fill=0
		for row in data:
			self.cell(w[0],4,row[0],'LR',0,'C',fill)
			self.cell(w[1],4,row[2],'LR',0,'C',fill)
			a =secore(row[6])
			self.cell(w[2],4,a,'LR',0,'C',fill)
			self.ln()
			#fill=not fill
		
		self.cell(sum(w),0,'','T')
		self.ln()
		
	def rqq_rw_table(self,header,data):
		#Colors, line width and bold font
		self.set_fill_color(255,0,0)
		self.set_text_color(255)
		self.set_draw_color(128,0,0)
		self.set_line_width(.2)
		self.set_font('','',10)
		#Header
		w=[40,40]
		for i in range(0,len(header)):
			self.cell(w[i],7,header[i],1,0,'C',1)
		self.ln()
		#Color and font restoration
		self.set_fill_color(224,235,255)
		self.set_text_color(0)
		self.set_font('')
		#Data
		fill=0
		for row in data:
			self.cell(w[0],4,row.__str__(),'LR',0,'C',fill)
			
		self.ln()
		self.cell(sum(w),0,'','T')
		self.ln()
	
	def lavoro_table(self,header,data):
		#Colors, line width and bold font
		self.set_fill_color(255,0,0)
		self.set_text_color(255)
		self.set_draw_color(128,0,0)
		self.set_line_width(.2)
		self.set_font('','',10)
		#Header
		w=[16,16,16,16,16,16,16,16,16,16,16,16]
		for i in range(0,len(header)):
			self.cell(w[i],7,header[i],1,0,'C',1)
		self.ln()
		#Color and font restoration
		self.set_fill_color(224,235,255)
		self.set_text_color(0)
		self.set_font('')
		#Data
		fill=0
		column = 0
		for row in data:
			a =secore(row[0])
			self.cell(w[column],4,a,'LR',0,'C',fill)
			column += 1 
			#
			#fill=not fill
		self.ln()
		self.cell(sum(w),0,'','T')
		self.ln()	
	def riposi_fr_table(self,header,data):
		#Colors, line width and bold font
		self.set_fill_color(255,0,0)
		self.set_text_color(255)
		self.set_draw_color(128,0,0)
		self.set_line_width(.2)
		self.set_font('','',10)
		#Header
		w=[16,16,16,16,16,16,16,16,16,16,16,16]
		for i in range(0,len(header)):
			self.cell(w[i],7,header[i],1,0,'C',1)
		self.ln()
		#Color and font restoration
		self.set_fill_color(224,235,255)
		self.set_text_color(0)
		self.set_font('')
		#Data
		fill=0
		column = 0
		for row in data:
			self.cell(w[column],4,row.__str__(),'LR',0,'C',fill)
			column += 1 
			#
			#fill=not fill
		self.ln()
		self.cell(sum(w),0,'','T')
		self.ln()
def secore(secondi):
    a=secondi
    b=a%3600
    d=a%60
    b/=60
    c = repr(b)
    if len(c) == 1:
        b *= 10
        b = repr(b)
        b=b[::-1]
    if a/3600==1:
        orae='ora'
    else:
        orae='ore'
    return int((a/3600)).__str__() + 'h ' + int(b).__str__() + 'm'	
  
def secore_new(secondi):
    a=secondi
    b=a%3600
    d=a%60
    b/=60
    c = repr(b)
    if len(c) == 1:
        b *= 10
        b = repr(b)
        b=b[::-1]
    if a/3600==1:
        orae='ora'
    else:
        orae='ore'
    return int(a/3600), int(b)
  
def spezza_data(data_string):
  #Prende in input una stringa nel formato GG/MM/AAAA, estrae giorno,mese,anno e ritorna il risultato.
	giorno = 0 
	mese = 0
	anno = 0
	giorno = data_string[0:data_string.find('/')]
	data_string = data_string[data_string.find('/')+1:]
	mese = data_string[0:data_string.find('/')]
	data_string = data_string[data_string.find('/')+1:]
	anno = data_string[0:]
	return giorno, mese, anno

def s_to_int(string_number):
  #Effettua la conversione da stringa ad intero

	try:
		i = int(string_number)
	except ValueError:
		i = 0
	return i
"""La funzione va riscritta utilizzando datetime """
def is_i_t_notte(i_list):
  #True se inizio periodo riposo ricade nella fascia 0.00-6.00, False altrimenti
	secondi_i_t = 0
	secondi_f_t = 0
	secondi_i_r = 0
	inizio_t = [s_to_int(i_list[0]), s_to_int(i_list[1]),s_to_int(i_list[2]),s_to_int('0'),s_to_int('00'),0,0,0,0]
	fine_t = [s_to_int(i_list[0]), s_to_int(i_list[1]),s_to_int(i_list[2]),s_to_int('6'),s_to_int('00'),0,0,0,0]
	inizio_r = [s_to_int(i_list[0]), s_to_int(i_list[1]),s_to_int(i_list[2]),s_to_int(i_list[3]),s_to_int(i_list[4]),0,0,0,0]
	
	secondi_i_t = time.mktime(inizio_t)
	secondi_f_t = time.mktime(fine_t)
	secondi_i_r = time.mktime(inizio_r)
	
	if (secondi_i_r >= secondi_i_t) and (secondi_i_r <= secondi_f_t):
		return True
	return False	

def is_riposo_minimo(ore):
  #True se il riposo e' inferiore a 48 ore
	if ore < 48:
		return True
	return False


def is_sabato_eo_domenica(g_inizio,g_fine):
#verifica se le date input sono comprese tra sabato e/o domenica
#restituisce una coppia di valori true/false rispettivamente per la presenza
#di sabato(T/F) domenica(F/T) o entrambe (F/F) (T/T)
	day_list = []
	sabato = 0 
	domenica = 0
	
	if g_inizio == 6 or g_fine == 6:
	  sabato += 1
	if g_inizio == 7 or g_fine == 7:
	  domenica += 1
	if sabato == 1 and domenica == 1:
		return True,True
	if sabato == 1 and domenica == 0:
		return True,False
	if sabato == 0 and domenica == 1:
		return False,True
	else:
		return False,False


def calcola_range(lista_prestazioni):
#calcola l'intervallo di date inizio e fine del file di input, ritorna inizio e fine.ATTENZIONE il file non deve contenere \n alla fine, pena il mancato funzionamento
#TODO implementare controllo
	j = len(lista_prestazioni)
	inizio = ''
	fine = ''
	t,inizio,oi,df,of = spezza_righe(lista_prestazioni[0])
	t,gi,oi,fine,of = spezza_righe(lista_prestazioni[j-1])  	
	return inizio,fine	

def calcola_giorni(anno_i, mese_i, giorno_i, anno_f, mese_f, giorno_f): 
  """calcola il numero di giorni tra due date ritorna il numero di giorni"""
 
	
  inizio = datetime.datetime(anno_i,mese_i,giorno_i)
  fine  = datetime.datetime(anno_f,mese_f,giorno_f)
  return (fine.__sub__(inizio)).days


def ricerca_espressioni(html_file_to_search):
  """La funzione ricerca espressioni all'interno del file html dato, le RegExp ricercate sono: HH:MM | DD/MM/YYYY | NON ASSEGNATO | RIPOSO |DISPONIBILITA |ASSENZA |INTERVALLO |FERIE """
  """ritorna la lista delle espressioni trovate """
  i,a = 0,0
  list = []
  f=file(html_file_to_search,'r')
  text = f.read()
  list = re.findall('<b>[0-9+][0-9+][/][0-9+][0-9+][/][0-9+][0-9+][0-9+][0-9+]|[0-9+][0-9+][:][0-9+][0-9+]|NON&#160;ASSEGNATO|RIPOSO|DISPONIBILITA|ASSENZA|INTERVALLO|FERIE|CORSO|VISITA&#160;MEDICA',text)
  while i < len(list):
    a = list[i].find('<b>')
    if a != -1:
      list[i] = list[i][a+3:]
    
    b = list[i].find('&#160;')
    if b != -1:
      list[i] = list[i][0:b] + list[i][b+6:]
    i = i + 1
  return list
#print ricerca_espressioni('s.html')

def suddividi_dati_servizi(re_list):
  """La funzione riceve una lista contenente dati di turno, identificabili attraverso espressioni regolari, restituisce 
     una lista contenente le lunghezze dei pattern contraddistinti da --> DD/MM/AAAA, 2  REGEXP del tipo [HH:MM] oppure 
     1 REGEXP del tipo [RIPOSO| INTERVALLO| DISPONIBILITA| ASSENZA| NON ASSEGNATO| ecc], quindi DD/MM/AAAA.
     Esempio con la lista di input ['16/09/2012','RIPOSO','17/09/2012','14:22','22:34','18/09/2012','12:37','19:56']
     la funzione restituisce la lista [2,3,3]"""
  count = 0 
  start = 0
  length_list = []
  # Le espressioni iniziano sempre con una data, distinguiamo i casi che e' possibile ritrovare:
  #     -1 se si tratta di una giornata lavorativa AR avremo || giorno, orario inizio , orario fine || LUNGHEZZA 3
  #     -2 se si tratta di una giornata lavorativa RFR avremo || giorno, orario inizio  || per la giornata di andata e 
  #         se si tratta di una giornata lavorativa AR avremo || giorno , orario fine || per la giornata di ritorno. LUNGHEZZA 2 + 2
  #     -3 se si tratta di una giornata non lavorativa mobile si avra' ||giorno, tipo attivita' ||  LUNGHEZZA 2
  #    La strategia utilizzata e' quella di creare una lista delle lunghezze incontrate, utili a distinguere successivamente i 3 casi
  #    elencati.
  for elements in (re_list):
    data =  re.match('[0-9+][0-9+][/][0-9+][0-9+][/][0-9+][0-9+][0-9+][0-9+]', elements)
    if data:
      start = 1
    if not (data) and start == 1:#se ho gia incontrato una data, allora posso contare l'occorrenza 
      count += 1
    if data and count > 0:#siamo in presenza del termine del pezzo di dato a cui siamo interessati
      length_list.append(count+1)
      count = 0
  length_list.append(count+1)
  #print "length list" ,length_list,'\n'
  return length_list

def write_data_in_order(re_list, lista_dati_servizi):
  list = []
  counter = 0
  global_counter = 0
  s = []
  """La funzione si occupa della scrittura delle espressioni di turno ricevute in input, su file, formattando 
     l'output nella forma DD/MM/YYYY| DATI SERVIZIO/ 
     Restituisce 1 in caso di successo, -1 in caso di insuccesso, None se non e' stato scritto nulla nel file."""
  for elements in (lista_dati_servizi):
    while counter < elements:
      s.append(re_list[global_counter])
      counter += 1
      global_counter += 1
     
    list.append(s)
    #global_counter += counter
    counter = 0
    s = []
  #print list
  return list

def calcola_giorni(anno_i, mese_i, giorno_i, anno_f, mese_f, giorno_f):
#calcola il numero di giorni tra due date
# ritorna il numero di giorni
	#datetime.timedelta(0, 0, 1)
	inizio = datetime.datetime(anno_i,mese_i,giorno_i)
	fine  = datetime.datetime(anno_f,mese_f,giorno_f)
	return (fine.__sub__(inizio)).days
#print calcola_giorni(2012,9,17,2012,12,8)

def data_decorator(data_list):
  
  """ La funzione si occupa di trasformare i dati di turno aventi una delle forme {DD/MM/AAAA HH:MM} oppure	
      {DD/MM/AAAA HH;MM HH:MM} {DD/MM/AAAA tipo servizio} nel formato lunghezza fissa presente nel file turno caratterizzato da:
      {tipo servizio}-->[AR,RFR,R,A,D,eccc] | {giorno inizio} | {ora inizio} | {data fine} | {ora fine}  
      es. --1 AR,15/9/2012,1318,15/9/2012,2234
	  --2 RIPOSO,16/9/2012,100,16/9/2012,2400
	  --3 AR,17/9/2012,1422,17/9/2012,2234
	  Le regole per l'assegnazione delle ore sono le seguenti:
	  --le giornate di riposo o intervallo sono contabilizzate in 24h ossia 
	  --le giornate di lavoro hanno una componente A--> dalle 24.00 all-ora di inizio prestazione e una B--> dal termine prestazione 
	    alle 0.00
	  --le rimanenti giornate non hanno valore assegnato
	  L'organizzazione ideata permette un rapida valutazione di quanto ogni giornata concorre al riposo settimanale oppure
	  giornaliero, infatti a titolo esplicativo esplicitiamo tale valutazione riferendosi all'esempio precedentemente.
	  La giornata 1 ha A--> 13h18m B-->1h26m, giornata 2 ha 24h di riposo, infine la giornata 3 ha A-->14.22 B-->1h26m. 
	  Per al valutazione delle ore di riposo dobbiamo sommare B di 1 + riposo di 2 + A di 3, avremo quindi
	  che le ore di riposo sono date da 1h26m + 24h + 14h22m = 49h48m.
	  Il risultato dell'elaborazione viene accodato all-interno della lista di input, i dati accodati sono nell-ordine di accodamento
	  sec_A|sec_B|prest_giorn|riposo, quest-ultimo campo viene valorizzato a 86400 solo per le giornate intere di riposo o intervallo."""
  tone = 0	      
  file_data = file("dati.txt","w")
  tone_f = file ("tone.txt","w")
  file_data.write("# data prestazione_giornaliera\n")
  riposo_list = []
  prestazione_mensile = [[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0]]  
  riposi_fuori_residenza = [0,0,0,0,0,0,0,0,0,0,0,0]
  calendario = []
  #prestazione mensile contiene nella posizione 0 la somma delle prestazioni lavorative del mese indicato dall-index della lista
  # mentre nella posizione 1 la somma dei riposi mensili indicati dall'index della lista
  dati_formattati_tabella = []
  dati_aggiunti = [] #  [ data, lavoro, riposo_g, rfr]
  sec_A,sec_B, prest_giorn,riposo = 0,0,0,0
  rfr = 0
  rfr_count = 0
  index = 0 
  for elements in data_list:
    #cattura pattern data, serve per il caso dei RFR
    rfr = re.match('[0-9+][0-9+][:][0-9+][0-9+]', elements[1])
    #print 'elements: %s len: %d \n' % (elements,len(elements))
    #print "*******************data_decorator***************" ,data_list,'\n'
    #print elements
    if len(elements) == 4 and elements[1] == 'DISPONIBILITA':
      #Gestione del caso di disponibilita con termine massimo prestazione prestabilito DISPONIBILITA fine: HH:MM
      #in questo caaso devo calcolare solo sec_B"""
      lavoro = elements.pop()
      ora_temp = ''
      ora_temp = elements.pop()
      elements.append('00:00')
      elements.append(ora_temp)
      orario = 0
      riposo,sec_A,sec_B,prest_giorn = 0,0,0,27360# 7 h 36 m
      giorno, mese, anno = spezza_data(elements[0])
      ora,minuti = elements[3][:2] , elements[3][3:]
      #print 'disponibiliat',elements[3][:2] , elements[3][3:],'\n'
      orario = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),s_to_int(ora),s_to_int(minuti) )
      under_mezzanotte = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),23,59,59)
      elements.append(sec_A)
      sec_B = (under_mezzanotte.__sub__(orario)).total_seconds()+1
      #print "SEC_B disponibilita",sec_B,'\n'
      elements.append(sec_B)
      elements.append(prest_giorn)
      elements.append(riposo)
      dati_formattati_tabella.append([elements[0],elements[1],'',ora_temp,prest_giorn])
      dati_aggiunti.append([elements[0],lavoro,0,0])
      prestazione_mensile[s_to_int(mese) - 1][0] += prest_giorn
      file_data.write('%s %s \n' % (elements[0],prest_giorn))
      tone -= prest_giorn
      tone_f.write("%s %s \n" % (elements[0],tone) )
      calendario.append([elements[0],elements[1],'',ora_temp])
      #print elements
    if len(elements) == 6:#L'unico caso in cui si ha: (data, ora inizio, ora termine) corrisponde ad un servizio AR (andata e ritorno)
	#print 'elements: %s len: %d \n' % (elements,len(elements))
	riposo_g,c_eff,lavoro = elements.pop(), elements.pop(), elements.pop()
	giorno, mese, anno = spezza_data(elements[0])
	ora_i,minuti_i = elements[1][:2] , elements[1][3:]
	#print ora_i,minuti_i,'data hour inizio\n'
	ora_f,minuti_f = elements[2][:2] , elements[2][3:]
	#print ora_f,minuti_f,'data hour fine\n'
	inizio = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),s_to_int(ora_i),s_to_int(minuti_i) )
	#print s_to_int(anno),s_to_int(mese),s_to_int(giorno),s_to_int(ora_i),s_to_int(minuti_i),'inizio data \n'
	fine = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),s_to_int(ora_f),s_to_int(minuti_f) )
	under_mezzanotte = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),23,59,59)
	over_mezzanotte = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),00,00,00)
	sec_A = (inizio.__sub__(over_mezzanotte)).total_seconds()
	elements.append(sec_A)
	sec_B = (under_mezzanotte.__sub__(fine)).total_seconds()+1
	elements.append(sec_B)
	prest_giorn = fine.__sub__(inizio).total_seconds()
	elements.append(prest_giorn)
	riposo = 0 
	elements.append(riposo)
	rfr = 0
	dati_formattati_tabella.append([elements[0],'AR',elements[1],elements[2],prest_giorn])
	dati_aggiunti.append([elements[0],lavoro,riposo_g,0])
	prestazione_mensile[s_to_int(mese) - 1][0] += prest_giorn
	file_data.write('%s %s \n' % (elements[0],prest_giorn))
	tone -=  prest_giorn 
	tone_f.write("%s %s \n" % (elements[0],tone) )
	calendario.append( [elements[0],'AR',elements[1],elements[2] ])
	#print 'giorno %s A: %d B: %d prest. giornaliera %d \n'% (elements[0],sec_A,sec_B,prest_giorn)
	#print elements
    if len(elements) == 2 and  elements[1] == 'INTERVALLO':#le giornate riposo e intervallo hanno esclusivamente
	
	riposo_list.append(index)
	riposo_list.append(elements[0])
	riposo_list.append(elements[1])
	riposo,sec_A,sec_B,prest_giorn = 86400,0,0,0#l'attributo riposo che conta di 86400 secondi
	elements.append(sec_A)
	elements.append(sec_B)
	elements.append(prest_giorn)
	elements.append(riposo)
	rfr = 0 
	dati_formattati_tabella.append([elements[0],elements[1],'','',prest_giorn])
	file_data.write('%s %s \n' % (elements[0],prest_giorn))
	tone += riposo 
	tone_f.write("%s %s \n" % (elements[0],tone) )
	calendario.append( [elements[0],elements[1] ])
	#print elements
    if len(elements) == 2 and ( elements[1] == 'FERIE' or elements[1] == 'NONASSEGNATO'):#le giornate riposo e intervallo hanno esclusivamente
	giorno, mese, anno = spezza_data(elements[0])
	riposo,sec_A,sec_B,prest_giorn = 0,0,0,0
	elements.append(sec_A)
	elements.append(sec_B)
	elements.append(prest_giorn)
	elements.append(riposo)
	rfr = 0 
	dati_formattati_tabella.append([elements[0],elements[1],'','',prest_giorn])
	file_data.write('%s %s \n' % (elements[0],prest_giorn))
	tone += riposo 
	tone_f.write("%s %s \n" % (elements[0],tone) )
	if elements[1] == 'FERIE':
	  calendario.append( [elements[0], 'FERIE'] )
    
    if len(elements) == 3 and  elements[1] == 'RIPOSO':#le giornate riposo e intervallo hanno esclusivamente
	riposo_s = elements.pop()
	riposo_list.append(index)
	riposo_list.append(elements[0])
	riposo_list.append(elements[1])
	riposo,sec_A,sec_B,prest_giorn = 86400,0,0,0#l'attributo riposo che conta di 86400 secondi
	elements.append(sec_A)
	elements.append(sec_B)
	elements.append(prest_giorn)
	elements.append(riposo)
	rfr = 0 
	dati_formattati_tabella.append([elements[0],elements[1],'','',prest_giorn])
	dati_aggiunti.append([elements[0],0,riposo_s,0])
	file_data.write('%s %s \n' % (elements[0],prest_giorn))
	tone +=riposo
	tone_f.write("%s %s \n" % (elements[0],tone) )
	calendario.append( [elements[0],elements[1] ])
	
    if len(elements) == 3 and (elements[1] == 'DISPONIBILITA'):
	giorno, mese, anno = spezza_data(elements[0])
	lavoro_g = elements.pop()			        
	riposo,sec_A,sec_B,prest_giorn = 0,0,0,27360
	elements.append(sec_A)
	elements.append(sec_B)
	elements.append(prest_giorn)
	elements.append(riposo)
	rfr = 0
	dati_formattati_tabella.append([elements[0],elements[1],'','',prest_giorn])
	dati_aggiunti.append([elements[0],lavoro_g,0,0])
	prestazione_mensile[s_to_int(mese) - 1][0] += prest_giorn
	file_data.write('%s %s \n' % (elements[0],prest_giorn))
	tone -= prest_giorn 
	tone_f.write("%s %s \n" % (elements[0],tone) )
	calendario.append( [elements[0],elements[1]] )
	
    if len(elements) == 4 and (elements[1] == 'CORSO'):
	giorno, mese, anno = spezza_data(elements[0])
	riposo_g, lavoro_g = elements.pop(), elements.pop()										  
	riposo,sec_A,sec_B,prest_giorn = 0,0,0,27360
	elements.append(sec_A)
	elements.append(sec_B)
	elements.append(prest_giorn)
	elements.append(riposo)
	rfr = 0
	dati_formattati_tabella.append([elements[0],elements[1],'08:00','16:06',prest_giorn])
	dati_aggiunti.append([elements[0],lavoro_g,0,0])
	prestazione_mensile[s_to_int(mese) - 1][0] += prest_giorn
	file_data.write('%s %s \n' % (elements[0],prest_giorn))
	tone -= prest_giorn
	tone_f.write("%s %s \n" % (elements[0],tone) )
	calendario.append( [elements[0],elements[1],'08:00','16:06'] )
	
    if len(elements) == 4 and (elements[1] == 'VISITAMEDICA'):
	giorno, mese, anno = spezza_data(elements[0])
	riposo_g, lavoro_g = elements.pop(), elements.pop()										  
	riposo,sec_A,sec_B,prest_giorn = 0,0,0,27360
	elements.append(sec_A)
	elements.append(sec_B)
	elements.append(prest_giorn)
	elements.append(riposo)
	rfr = 0
	dati_formattati_tabella.append([elements[0],elements[1],'08:00','16:06',prest_giorn])
	dati_aggiunti.append([elements[0],lavoro_g,0,0])
	prestazione_mensile[s_to_int(mese) - 1][0] += prest_giorn
	file_data.write('%s %s \n' % (elements[0],prest_giorn))
	tone -= prest_giorn
	tone_f.write("%s %s \n" % (elements[0],tone) )
	calendario.append( [elements[0],elements[1],'08:00','16:06'] )
	#print elements
	"""La gestione dei RFR non e' attualmemte posssibile poiche' mancano i dati ora_termine andata e ora_inizio ritorno, si potrebbe infuturo implementare un data-fit delle sole giornate
	    di RFR ."""
    if len(elements) == 5 and rfr and rfr_count == 0:#Inizialmente manca uno dei due orari, verra' impostato uno fittizio 00:00 per mantenere la
				   #stessa organizzazione dei campi 
	#se si tratta della giornata di andata di un RFR posso calcolare solo sec_A.
	rfr_d,c_eff,lavoro_g = elements.pop() , elements.pop(), elements.pop()
	
	elements.append('00:00')
	orario = 0
	rfr_count = 1
	riposo,sec_A,sec_B,prest_giorn = 0,0,0,0
	giorno, mese, anno = spezza_data(elements[0])
	ora_i,minuti_i = elements[1][:2] , elements[1][3:]
	ora_lavoro, minuti_lavoro = lavoro_g[:2],lavoro_g[-2:]
	secondi_lavoro_i = (s_to_int(ora_i) * 3600 ) + (s_to_int(minuti_i) * 60)
	secondi_lavoro = (s_to_int(ora_lavoro) * 3600 ) + (s_to_int(minuti_lavoro) * 60)
	secondi_lavoro += secondi_lavoro_i
	h,m = secore_new(secondi_lavoro)
	if h == 24 and m == 0:
	  h = 23
	  m = 59
	ora = '%d:%d' % (h,m)
	
	if m == 0:
	  m = 00
	ora = '%d:%d' % (h,m)
	
	#elements.append(ora)
	print anno,mese,giorno,ora_i,minuti_i,h,m,'cazzoooo'
	orario_t = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),h,m )
	orario = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),s_to_int(ora_i),s_to_int(minuti_i) )
	print orario_t,orario,'ORARIIIIII!\n' 
	over_mezzanotte = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),00,00,00)
	under_mezzanotte = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),23,59,59)
	sec_A = (orario.__sub__(over_mezzanotte)).total_seconds()
	sec_B = (under_mezzanotte.__sub__(orario_t)).total_seconds()+1
	#print 'orario e orario_t',orario,orario_t,'\n'
	prest_giorn = orario_t.__sub__(orario).total_seconds()
	prestazione_mensile[s_to_int(mese) - 1][0] += prest_giorn
	elements.append(sec_A)
	elements.append(sec_B)
	elements.append(prest_giorn)
	elements.append(riposo)
	
	
	rfr = 0
	dati_formattati_tabella.append([elements[0],'RFR',elements[1],ora,prest_giorn])
	dati_aggiunti.append([elements[0],lavoro_g,0,rfr_d])
	file_data.write('%s %s \n' % (elements[0],prest_giorn))
	tone -= prest_giorn 
	tone_f.write("%s %s \n" % (elements[0],tone) )
	calendario_temp = []
	calendario_temp.append(elements[0]  )
	calendario_temp.append('RFR')
	calendario_temp.append(elements[1])
	#print "into RFR andata", sec_A,sec_B,'\n'
    if len(elements) == 5 and rfr and rfr_count == 1:#se si tratta della giornata di ritorno di un RFR posso calcolare solo sec_B.
	riposo_g,c_eff,lavoro_g = elements.pop(), elements.pop(), elements.pop()
	
	ora_temp = ''
	ora_temp = elements.pop()
	elements.append('00:00')
	elements.append(ora_temp)
	orario = 0
	rfr_count = 0
	riposo,sec_A,sec_B,prest_giorn = 0,0,0,0
	giorno, mese, anno = spezza_data(elements[0])
	ora_t,minuti_t = elements[2][:2] , elements[2][3:]
	#print ora_t,minuti_t,'\n'
	ora_lavoro, minuti_lavoro = lavoro_g[:2],lavoro_g[-2:]
	secondi_lavoro_t = (s_to_int(ora_t) * 3600 ) + (s_to_int(minuti_t) * 60)
	secondi_lavoro = (s_to_int(ora_lavoro) * 3600 ) + (s_to_int(minuti_lavoro) * 60)
	secondi_lavoro = secondi_lavoro_t - secondi_lavoro
	h,m = secore_new(secondi_lavoro)
	ora = '%d:%d' % (h,m)
	#ora_temp = elements.pop()
	#elements.pop()
	#elements.append(ora)
	#elements.append(ora_temp)
	orario_t = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),s_to_int(ora_t),s_to_int(minuti_t) )
	
	
	orario_i = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),h,m) 
	over_mezzanotte = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),00,00,00)
	under_mezzanotte = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),23,59,59)
	sec_A = (orario_i.__sub__(over_mezzanotte)).total_seconds()
	elements.append(sec_A)
	sec_B = (under_mezzanotte.__sub__(orario_t)).total_seconds()+1
	#print 'orario e orario_t',orario_i,orario_t,'\n'
	#print sec_B,'sec_B \n'
	elements.append(sec_B)
	prest_giorn = orario_t.__sub__(orario_i).total_seconds()
	prestazione_mensile[s_to_int(mese) - 1][0] += prest_giorn
	#print 'prestazione %s \n' % prest_giorn
	elements.append(prest_giorn)
	elements.append(riposo)
	rfr = 0
	dati_formattati_tabella.append([elements[0],'RFR',ora,elements[2],prest_giorn])
	#attenzione il campo riposo_g puo' presentarsi 0:00 nel caso di riposo settimanale seguente la giornata in esame 
	dati_aggiunti.append([elements[0],lavoro_g,riposo_g,0])
	file_data.write('%s %s \n' % (elements[0],prest_giorn))
	#print "into RFR ritorno", sec_A,sec_B,'\n'
	tone -= prest_giorn 
	tone_f.write("%s %s \n" % (elements[0],tone) )
	riposi_fuori_residenza[s_to_int(mese) - 1] += 1
	calendario_temp.append(elements[2])
	calendario.append([calendario_temp])
    index += 1
  #print 'riposo list', riposo_list,'\n'
  #print 'data decorator data_list',data_list ,'\n'
  #print 'data decorator dati_formattati',dati_formattati_tabella, '\n'
  return riposi_fuori_residenza,calendario,prestazione_mensile,data_list,riposo_list,dati_formattati_tabella,dati_aggiunti
 
#print suddividi_dati_servizi(ricerca_espressioni('html.html'))

#print write_data_in_order(ricerca_espressioni('html.html'), suddividi_dati_servizi(ricerca_espressioni('html.html')) )

def computa_riposo(data_list,riposo_list):
  riposo_data = file("riposi.txt","w")
  """La funzione computa la durata dei riposi settimanali contenuti all'interno di data_list. 
IL calcolo ottiene i dati prelevandoli dalla data_list modificata dalla funzione data_decorator e utilizzando una lista con sentinelle 
per la rilevazione delle giornate di riposo/intervallo.
Crea e restituisce una lista contenente i riposi con relative durate in secondi e se coincidenti con sabato e/o domenica."""
  
  computed_riposo = []
  doppio = False
  riposo_start = '' 
  riposo_stop = ''
  sec_riposo = 0
  sabato,domenica = False,False
  while riposo_list:
      index_start = riposo_list.pop(0)
      data_start = riposo_list.pop(0)
      data_start_iso = datetime.date(s_to_int(data_start[6:]),s_to_int(data_start[3:5]),s_to_int(data_start[:2])).isocalendar()
      riposo_s,riposo_d = is_sabato_eo_domenica(data_start[2],data_start_iso[2])
      #print data_start,riposo_s,riposo_d,'\n'
      tipo_uno = riposo_list.pop(0)
      
      
      
      if riposo_list and index_start+1 == riposo_list[0]:
	doppio = True
	index_stop = riposo_list.pop(0)
	data_stop = riposo_list.pop(0)
	data_stop_iso = datetime.date(s_to_int(data_stop[6:]),s_to_int(data_stop[3:5]),s_to_int(data_stop[:2])).isocalendar()
	riposo_s_s, riposo_d_d = is_sabato_eo_domenica(data_start[2],data_stop_iso[2])
	#print data_stop,riposo_s_s, riposo_d_d,'\n'
	tipo_due = riposo_list.pop(0)
	if index_start-1 == -1:
	  computed_riposo.append([ data_list[index_start][0],data_list[index_stop+1][0], data_list[index_start][4] + data_list[index_start][5] + data_list[index_stop][5] + data_list[index_stop+1][3],riposo_s or riposo_s_s,riposo_d or riposo_d_d ] )
	  riposo_data.write("%s %s %s \n" % (data_list[index_start][0], data_list[index_stop+1][0], data_list[index_start][4] + data_list[index_start][5] + data_list[index_stop][5] + data_list[index_stop+1][3] ) )
	else:
	  computed_riposo.append([ data_list[index_start-1][0],data_list[index_stop+1][0], data_list[index_start-1][4] + data_list[index_start][5] + data_list[index_stop][5] + data_list[index_stop+1][3],riposo_s or riposo_s_s,riposo_d or riposo_d_d ] )
	  riposo_data.write("%s %s %s \n" % (data_list[index_start-1][0], data_list[index_stop+1][0], data_list[index_start-1][4] + data_list[index_start][5] + data_list[index_stop][5] + data_list[index_stop+1][3] ) )
	  #print ("%s %s %s %s\n" % (data_list[index_start-1][4] , data_list[index_start][5] , data_list[index_stop][5] , data_list[index_stop+1][3] ) )
      if not doppio and index_start !=0:
	print index_start-1,index_start,index_start+1
	if index_start+1 == len(data_list):
	  rip = data_list[index_start-1][4] + data_list[index_start][5]
	  if rip < (86400*2):
	    rip = 86400 * 2
	  computed_riposo.append([ data_list[index_start-1][0],data_list[index_start][0], rip,riposo_s,riposo_d ])
	else:
	  rip = data_list[index_start-1][4] + data_list[index_start][5] + data_list[index_start+1][3]
	  if rip < (86400*2):
	    rip = 86400 * 2
	  computed_riposo.append([ data_list[index_start-1][0],data_list[index_start+1][0], rip,riposo_s,riposo_d ])
	#riposo_data.write("%s %s %s \n" % (data_list[index_start-1][0], data_list[index_stop+1][0], data_list[index_start][5] + data_list[index_start+1][3]) )
      doppio = False
      riposo_d,riposo_s,riposo_d_d,riposo_s_s = False,False,False,False
      #print 'dentro calcola riposo ' , computed_riposo,'\n'
  return computed_riposo
  
def calcola_catenella(data_list):
  catenella = []	
  length = len(data_list)
  indice = 1 
  for elemento in data_list:#carico la prestazione giornaliera nel campo catenella
    print elemento  
    if elemento[1] != 'RIPOSO' and elemento[1] !='INTERVALLO' and elemento[1] !='ASSENZA'  and elemento[1] !='FERIE' and elemento[1] !='NONASSEGNATO' and elemento[1] !='VISITAMEDICA'and not elemento[1] == 'DISPONIBILITA' and not  elemento[1] =='CORSO':
      
      elemento.append(elemento[5])
    elif elemento[1] == 'DISPONIBILITA' or elemento[1] =='CORSO':
      elemento.append(0)
      elemento.append(elemento[4])
    else:
      elemento.append(0)
      """nel caso di riposo e intervallo, poiche' il campo [5] contiene il riposo,non devo inserire tale valore, la prestazione di queste giornate e' 0."""
      elemento.append(0)#piu' un campo di padding per pareggiare il numero di campi all-interno di data_list.
    #print elemento,'\n'
  catenella.append(data_list[indice-1][7] )
 
  while indice < length:
    
   
    if indice == 1:
      catenella.append( data_list[indice][7] + data_list[indice-1][7]) 
    if indice == 2:
      catenella.append(data_list[indice][7] + data_list[indice-1][7] + data_list[indice-2][7])
    if indice == 3:
      catenella.append(data_list[indice][7] + data_list[indice-1][7] + data_list[indice-2][7] + data_list[indice-3][7])
    if indice == 4:
      catenella.append(data_list[indice][7] + data_list[indice-1][7] + data_list[indice-2][7] + data_list[indice-3][7] + data_list[indice-4][7])
    if indice == 5:
      catenella.append(data_list[indice][7] + data_list[indice-1][7] + data_list[indice-2][7] + data_list[indice-3][7] + data_list[indice-4][7] + data_list[indice-5][7])
    if indice == 6:
     catenella.append( data_list[indice][7] + data_list[indice-1][7] + data_list[indice-2][7] + data_list[indice-3][7] + data_list[indice-4][7] + data_list[indice-5][7] + data_list[indice-6][7])
     
    if indice > 6:
      catenella.append(data_list[indice][7] + data_list[indice-1][7] + data_list[indice-2][7] + data_list[indice-3][7]+ data_list[indice-4][7]+ data_list[indice-5][7]+ data_list[indice-6][7])#+ data_list[indice-7][7])
    indice += 1 
    #print 'catenella dopo',catenella,'\n'
  return catenella 	

def accoda_catenella(dati_formattati_tabella, catenella):
  catenella_f = file('catenella.txt', 'w')
  index = 0
  if len(dati_formattati_tabella) != len(catenella):
    print 'ERROR list length \n'
    
  while index < len(dati_formattati_tabella):
    dati_formattati_tabella[index].append(catenella[index])
    catenella_f.write('%s %s \n' % (dati_formattati_tabella[index][0],catenella[index]) )
    index += 1 

def calcola_RFR(lista_dati):
  """La funzione ricerca giornate che hanno le caratteridtiche di RFR (termina e iniziano alle 00.00 e hanno valorizzati rispettivamente ed esclusivamente il campo sec_A
     e sec_B, infatti non e' possibile calcolarne la prestazione giornaliera, a motivo la mancanza del termine e inizio prestazione"""
  andata = 0
  RFR = []
  for elements in lista_dati:
    if andata:
      #RITORNO
      if elements[1] == '00:00' and elements[4] > 0:
	andata = 0 
	g_f = elements[0]
	o_f = elements[2]
	sec_B = elements[4]
	g_a, m_a, a_a = spezza_data(g_i)
	o_a,mi_a = o_i[:2] , o_i[3:]
	#print o_a,mi_a,'\n'
	gg_f, m_f, a_f = spezza_data(g_f)
	oo_f,mi_f = o_f[:2] , o_f[3:]
	#print o_f,mi_f,'\n'
	ora_a = datetime.datetime(s_to_int(a_a),s_to_int(m_a),s_to_int(g_a),s_to_int(o_a),s_to_int(mi_a) )
	ora_f = datetime.datetime(s_to_int(a_f),s_to_int(m_f),s_to_int(gg_f),s_to_int(oo_f),s_to_int(mi_f) )
	durata = ora_f.__sub__(ora_a).total_seconds()
	#print g_i,o_i,g_f,o_f,sec_A,sec_B,durata,'\n'
	RFR.append([g_i,o_i,g_f,o_f,sec_A,sec_B,durata])
	#ANDATA
    if elements[2] == '00:00' and elements[3] > 0:#orario termine == 00.00 e sec_A valorizzato !
      andata = 1
      g_i = elements[0]
      o_i = elements[1]
      sec_A = elements[3]
  return RFR

def calcola_disponibilita(data_list,dati_formattati_tabella):
  index = 0 
  """Sono alla prima righa della tabella e non posso calcolare la prestazione, questo perche la prestazione e'=  sec_B della riga precedente + 
    sommato a sec_A della riga attuale. """
  #if index == 0:
    #prestazione = 0
    #dati_formattati_tabella[index].append(prestazione)
    #index += 1 
  while index < len(dati_formattati_tabella):
    #print 'len' , len(data_list[index]), index, '\n'
    if index == len(dati_formattati_tabella)-1:
      #print len(dati_formattati_tabella),index
      prestazione = 0 
      dati_formattati_tabella[index].append(prestazione)
      #	dati_formattati_tabella[index+1].append(prestazione)
      break
    #if len(data_list[index]) == 7 and len(data_list[index+1]) ==7:
      #prestazione = data_list[index][4] + data_list[index+1][3]
    #if len(data_list[index]) == 7 and len(data_list[index+1]) ==8:
      #prestazione = data_list[index][4] + data_list[index+1][4]Domenica
    #if len(data_list[index]) == 7 and len(data_list[index+1]) ==6:
      #prestazione = data_list[index][4] + data_list[index+1][2]
    #if len(data_list[index]) == 8 and len(data_list[index+1]) ==8:
      #prestazione = data_list[index][5] + data_list[index+1][4]
    #if len(data_list[index]) == 8 and len(data_list[index+1]) ==7:
      #prestazione = data_list[index][5] + data_list[index+1][3]
    #if len(data_list[index]) == 8 and len(data_list[index+1]) ==6:
      #prestazione = data_list[index][5] + data_list[index+1][2]
    #if len(data_list[index]) == 6 and len(data_list[index+1]) ==6:
      #prestazione = data_list[index][3] + data_list[index+1][2]
    #if len(data_list[index]) == 6 and len(data_list[index+1]) ==7:
      #prestazione = data_list[index][3] + data_list[index+1][3]
    #if len(data_list[index]) == 6 and len(data_list[index+1]) ==8:
      #prestazione = data_list[index][3] + data_list[index+1][4]
    if data_list[index][1] == 'RIPOSO' or data_list[index][1] == 'INTERVALLO' or data_list[index+1][1] == 'RIPOSO' or data_list[index+1][1] == 'INTERVALLO':
      dati_formattati_tabella[index].append(0)
    else:
      prestazione = data_list[index][-4] + data_list[index+1][-5]
      #print "CALCOLA DISPONIBILITA" ,data_list[index-1][4], data_list[index][3], prestazione,'\n'
      dati_formattati_tabella[index].append(prestazione)
    
    index += 1 
  return dati_formattati_tabella
  

  
  
riposi_fr,calendario_data,prestazione_m,lista_dati,lista_riposo, dati_formattati_tabella,dati_aggiunti = data_decorator(write_data_in_order(ricerca_espressioni('html.html'), suddividi_dati_servizi(ricerca_espressioni('html.html')) ) )
data_inizio_turno = lista_dati[0][0]
data_fine_turno = lista_dati[-1][0]

durata_turno = calcola_giorni(s_to_int(data_inizio_turno[6:]),s_to_int(data_inizio_turno[3:5]),s_to_int(data_inizio_turno[0:2]),s_to_int(data_fine_turno[6:]),s_to_int(data_fine_turno[3:5]),s_to_int(data_fine_turno[0:2]))
print 'Durata Turno %d \n' % (durata_turno)
monte_riposi_annuali = 3420
ore_riposo_attese = (monte_riposi_annuali/365) * durata_turno
print 'ore_riposo_attese %d \n' % (ore_riposo_attese)
print 'prestazione mensile \n' ,prestazione_m ,'\n'
mese = 1
for element in prestazione_m:
  print 'mese %d ore %s' % (mese,secore(element[0])), '\n'
  mese += 1
#print "LISTA DATI REG EXP" ,lista_dati, '\n'
#print '*************************************************************************\n'
print '*******************************lista dati*********************************** prima catenella ', lista_dati,'\n'
print "************************dati aggiunti***************************\n",dati_aggiunti,'\n'
catenella = calcola_catenella(lista_dati)
print '*******************************lista dati*********************************** dopo catenella\n', lista_dati,'\n'
accoda_catenella(dati_formattati_tabella, catenella)
calcola_disponibilita(lista_dati,dati_formattati_tabella)
#print "LISTA DATI " ,lista_dati, '\n'
#print "DATI FORMATTATI TABELLA" ,dati_formattati_tabella,'\n'
#print "LISTA DATI REG EXP" ,lista_dati, '\n'
#print "LISTA RIPOSO" ,lista_riposo,'\n'
computed_riposo = computa_riposo(lista_dati,lista_riposo)

print "LISTA DATI dopo computa riposo\n" , computed_riposo, '\n'

print "CATENELLA\n", catenella, '\n'
riposo_fuori_residenza =  calcola_RFR(lista_dati)
#print "RIPOSO FUORI RESIDENZA" ,riposo_fuori_residenza, '\n'
print 'Calendario data', calendario_data,'\n'
print "riposi_fr",riposi_fr,'\n'

riposi_RQQ_RW = [0,0]#riposi qualitativi ... riposi quantitativi
for elementi in computed_riposo:
  if elementi[3] and elementi[4] and elementi[2] >= 216000:
    riposi_RQQ_RW[1] += 1
    print 'RW',elementi[0],elementi[1]
  if (elementi[3] or elementi[4]) and  not (elementi[3] and elementi[4]) and elementi[2] >= 172800:
    riposi_RQQ_RW[0] += 1
    print 'RQQ',elementi[0],elementi[1]
    
#print riposi_RQQ_RW
#****************CREAZIONE PDF*******************************

# Instanciation of inherited class
pdf=PDF()
pdf.alias_nb_pages()
pdf.add_page()
pdf.set_font('Times','B',18)
pdf.cell(0,10,'Riposi Settimanali \n',0,1)
riposo_header = ['Inizio','Fine','durata','RQQ/RW','RQQ / RW'] 
pdf.riposo_table(riposo_header,computed_riposo)

sabato,domenica = '',''
totale_riposi = 0
#pdf.cell(0,100,' ' ,0,1)
pdf.set_font('Times','',12)
for elements in computed_riposo:
  #print elements[2],'\n'
  totale_riposi += elements[2]
  if elements[3] == True:
    sabato = " Sabato"
  if elements[4] == True:
    domenica = "Domenica"
  #s_out = elements[0] + '  ' + elements[1] + '   ' + int(elements[2]/3600).__str__() + ' ore e ' + int((elements[2]/3600- int (elements[2]/3600))*60).__str__() + ' minuti' + ' ' + sabato + ' ' + domenica + ' \n'
  sabato,domenica = '',''
  #pdf.cell(0,4,s_out,0,1)
 # print totale_riposi,'\n'
riposi_str = secore(totale_riposi)
#pdf.set_xy(10,100)
pdf.set_font('Times','',12)
#pdf.cell(0,10,'Durata del turno: ' + durata_turno.__str__() + 'gg' + '\n',0,)
#pdf.ln()
pdf.cell(0,10,'Ore di riposo spettanti per il periodo considerato: ' + ore_riposo_attese.__str__() + 'h' ,0,)
pdf.ln()
pdf.cell(0,10,'Monte ore riposo nel periodo considerato: ' + riposi_str,0,)
pdf.ln()
pdf.set_font('Times','B',18)
pdf.cell(0,10,'Riposi Qualitativi/Quantitativi \n',0,1)
riposo_qq_w_header = ['Qualitativi (12) *','Quantitativi (14) ** ']
pdf.rqq_rw_table(riposo_qq_w_header,riposi_RQQ_RW)
pdf.set_font('Times','I',10)
pdf.cell(0,10,'* Riposi di almeno 48h coincidenti con sabato o domenica ** Riposi di almeno 60h coincidenti con sabato e domenica\n',0,1)
#pdf.ln()
pdf.set_font('Times','B',18)
pdf.cell(0,10,'Riposi fuori Residenza \n',0,1) 
rfr_header = ['Inizio','Fine','Durata'] 
pdf.rfr_table(rfr_header,riposo_fuori_residenza)
pdf.ln()
pdf.set_font('Times','B',18)
pdf.cell(0,10,'Riepilogo Mensile RFR \n',0,1)
lavoro_header = ['Gen','Feb','Mar','Apr','Mag','Giu','Lug','Ago','Set','Ott','Nov','Dic'] 
pdf.riposi_fr_table(lavoro_header,riposi_fr)

pdf.set_font('Times','B',18)
pdf.cell(0,10,'Lavoro Mensile \n',0,1) 
pdf.lavoro_table(lavoro_header,prestazione_m)
#pdf.set_font('Times','',12)
#for elements in riposo_fuori_residenza:
  #s_out = elements[0] + '--' + elements[2] + ' Assenza dalla residenza:    ' + int(elements[6]/3600).__str__() + ' ore e ' + int((elements[6]/3600- int (elements[6]/3600))*60).__str__() + ' minuti\n'
  #pdf.cell(0,4,s_out,0,1)

      
header=['Data','Descrizione','inizio','termine','prestazione','V','limite 44h','V']#,'disponibilita','V']#, 'Variaz.']
pdf.add_page()
pdf.fancy_table(header,dati_formattati_tabella)
pdf.output('turno2.pdf','F')
#print "LISTA DATI ",lista_dati
#print lista_riposo
#print catenella
#print len(catenella)
#print 'lista dati: %d catenella %d' % (len(lista_dati),len(catenella))
#ESPRESSIONE regolare per la ricerca della data in neretto 
#cat s.html |grep '<b>'[0-9+][0-9+][/][0-9+][0-9+][/][0-9+][0-9+][0-9+][0-9+]
#ricerca dell'ora inizio-termine servizio
# cat s.html |grep [0-9+][0-9+][:][0-9+][0-9+] ricerca ora inizio termine prestazione
# altri tipi di servizio RIPOSO, INTERVALLO, DISPONIBILITA, ASSENZA, NON ASSEGNATO, ecc
#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@  TODO @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
#riepilogo dati statistici del turno
#lavoro notturno
#sabato/domeniche lavorate
#lavoro giornaliero/settimanale/mensile medio
#frequenza dei rfr	
#riposi 14 periodi della durata di 60 ore consecutive sabato e domenica
#riposi 12 periodi della durata di 48 ore consecutive comprendenti sabato o domenica